home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Sample Code / AOCE Sample Code / PowerTalk Access Modules / Sample SMSAM / SampleSMSAM Source / BuildingBlocks / NewDelete.cp < prev    next >
Encoding:
Text File  |  1995-07-28  |  7.4 KB  |  366 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        NewDelete.cp
  3.  
  4.     Copyright:    © 1991-1994 by Apple Computer, Inc.
  5.                 All rights reserved.
  6.  
  7.     Part of the AOCE Sample SMSAM Package.  Consult the license
  8.     which came with this software for your specific legal rights.
  9.  
  10. */
  11.  
  12.  
  13.  
  14. #pragma trace off
  15.  
  16. #ifndef    __NEWDELETE__
  17. #include "NewDelete.h"
  18. #endif
  19.  
  20. #ifndef    __NEW__
  21. #include <New.h>
  22. #endif
  23.  
  24. #ifndef    __STDARG__
  25. #include "StdArg.h"
  26. #endif
  27.  
  28. #ifndef    __STDIO__
  29. #include "StdIO.h"
  30. #endif
  31.  
  32. #ifndef __DEBUGGINGGEAR__
  33. #include "DebuggingGear.h"
  34. #endif
  35.  
  36. #ifndef __DEBUGCONSTANTS__
  37. #include "DebugConstants.h"
  38. #endif
  39.  
  40. #ifndef    __THREAD_H
  41. // #include "Thread.h"
  42. #endif
  43.  
  44. #ifndef    __STDARG__
  45. #include "StdArg.h"
  46. #endif
  47.  
  48. #ifndef    __DEBUGASSERT__
  49. #include "DebugAssert.h"
  50. #endif
  51.  
  52. #ifndef    __HANDLEOBJECT__
  53. #include "HandleObject.h"
  54. #endif
  55.  
  56. #pragma segment Main
  57.  
  58. #ifndef THINK_CPLUS
  59. //    Think C++ can't handle multiple defns of a function.
  60. void* operator new ( size_t size ) { return ::AllocatePtr ( size ); }
  61. void operator delete ( void* p ) { ::DisposeIfPtr ( (Ptr) p ); }
  62. #endif
  63.  
  64. #ifndef THINK_CPLUS
  65.  
  66. void* TDirectObject::operator new ( size_t size ) { return ::AllocatePtr ( size ); }
  67. void TDirectObject::operator delete ( void* h ) { ::DisposeIfHandle ( (Handle) h ); }
  68.  
  69. void** HandleObject::operator new ( size_t size ) { return ::AllocateHandle ( size ); }
  70. void HandleObject::operator delete ( void** h ) { ::DisposeIfHandle ( (Handle) h ); }
  71. void** THandleObject::operator new ( size_t size ) { return ::AllocateHandle ( size ); }
  72. void THandleObject::operator delete ( void** h ) { ::DisposeIfHandle ( (Handle) h ); }
  73.  
  74. #else
  75.  
  76. void* TDirectObject::operator new ( size_t size ) { return ::AllocatePtr ( size ); }
  77. void TDirectObject::operator delete ( void* h ) { ::DisposeIfPtr ( (Ptr) h ); }
  78.  
  79. #endif
  80.  
  81. extern void Register ( const void*, const char* file, unsigned long line );
  82. extern void    Unregister ( const void* );
  83.  
  84. /***********************************|****************************************/
  85.  
  86. static void ReportError ( const char* format, ... )
  87. {
  88.     char buffer [ 128 ];
  89.     va_list val; va_start ( val, format );
  90.     buffer [ 0 ] = ::vsprintf ( buffer + 1, format, val );
  91.  
  92. #if debug
  93.     if ( chrisFlag.Flag ( kCallMacsbugOnMemErr ) )
  94. #endif
  95.         ::DebugStr ( (const StringPtr) buffer );
  96. #if debug
  97.     else
  98.         chris << buffer << endl;
  99. #endif
  100. }
  101.  
  102. /***********************************|****************************************/
  103.  
  104. void* BLJFailIfNil ( const void* p, const char* file, unsigned long line )
  105. {
  106. #if debug
  107.  
  108.     if ( !p ) 
  109.     {
  110.         keith << "FAILIFNIL: file " << file << ", line " << line << endl;
  111.         FAILOSErr ( -666 );
  112.     }
  113.  
  114. #else
  115.     
  116.     ::ReportError ( "FAILED: nil pointer; file %s, line %li", file, line );
  117.     
  118. #endif
  119.  
  120.     return (void*) p;
  121. }
  122.  
  123. /***********************************|****************************************/
  124.  
  125. Boolean ValidPtr ( const Ptr p )
  126. {
  127.     Boolean result = true;
  128.  
  129.     //    A pointer can't be odd.
  130.     if ((unsigned long) p & 1)
  131.         result = false;
  132.  
  133.     //    A pointer can't be 'below' the system heap (in low memory)
  134.     if (p <= (Ptr) SystemZone())
  135.         result = false;
  136.  
  137.     //    A pointer CAN be inside the system heap
  138.     if ((p >= (Ptr) SystemZone()) && (p <= SystemZone()->bkLim))
  139.     {
  140.         result = true;
  141.     }
  142.     else if ((p >= (Ptr) ApplicZone()) && (p <= ApplicZone()->bkLim))
  143.     {
  144.         result = true;
  145.     }
  146.     else
  147.     {
  148.         result = false;
  149.     }
  150.  
  151. #if debug
  152.     if (!result)
  153.     {
  154.         keith << "ValidPtr(" << (long) p << " given bad pointer." << endl;
  155.     }
  156. #endif
  157.  
  158.     return result;
  159. }
  160.  
  161. /***********************************|****************************************/
  162.  
  163. Boolean ValidHandle ( const Handle h )
  164. {
  165.     if ( ::ValidPtr ( (const Ptr) h ) )
  166.         return ::ValidPtr ( *h );
  167.  
  168.     return false;
  169. }
  170.  
  171. /***********************************|****************************************/
  172.  
  173. Boolean DisposeIfPtr ( Ptr p )
  174. {
  175.     if ( p != nil ) 
  176.         ::DeallocatePtr ( p );
  177.     
  178.     return true;
  179. }
  180.  
  181. /***********************************|****************************************/
  182.  
  183. Boolean DisposeIfHandle ( Handle h )
  184. {
  185.     if ( h != nil )
  186.         ::DeallocateHandle ( h );
  187.         
  188.     return true;
  189. }
  190.  
  191. /***********************************|****************************************/
  192.  
  193. void SetNewHandler ()
  194. {
  195. }
  196.  
  197. /***********************************|****************************************/
  198. /***********************************|****************************************/
  199.  
  200. #if debug 
  201.  
  202. // NOTE: the non-debug versions are implemented in NewDelete.h
  203.  
  204. Ptr AllocatePtr ( unsigned long bytes, Boolean clear, Boolean fail, const char* file, unsigned long line )
  205. {
  206.     if ( bytes > maxSize )
  207.     {
  208.         ::ReportError ( "AllocatePtr::Warning: size = %li", bytes );
  209.         bytes = 1;
  210.     }
  211.     else if ( bytes < 0 )
  212.     {
  213.         ::ReportError ( "AllocatePtr::Warning, size = %li", bytes );
  214.         bytes = 0;
  215.     }
  216.  
  217.     Ptr p = clear ? ::NewPtrClear ( bytes ) : ::NewPtr ( bytes );
  218.  
  219.     if ( !p )
  220.     {
  221.         ::ReportError ( "Error: Ptr = %p, MemErr = %i, size = %li", p, MemError (), bytes );
  222.         
  223.         if ( fail )
  224.             BLJFailIfNil ( p, file, line );
  225.     }
  226.     else if ( !clear )
  227.     {
  228.         ::memset ( p, 0xFF, (unsigned int) bytes );
  229.     }
  230.  
  231.     if ( chrisFlag.Flag ( 9 ) )
  232.         Register ( p, file, line );
  233.  
  234.     return p;
  235. }
  236.  
  237. /***********************************|****************************************/
  238.  
  239. Handle AllocateHandle ( unsigned long bytes, Boolean clear, Boolean fail, const char* file, unsigned long line )
  240. {
  241.     if (  bytes > maxSize )
  242.     {
  243.         ::ReportError ( "AllocateHandle::Warning: size = %li", bytes );
  244.         bytes = 1;
  245.     }
  246.  
  247.     Handle h = clear ? ::NewHandleClear ( bytes ) : ::NewHandle ( bytes );
  248.  
  249.     if ( !h )
  250.     {
  251.         ::ReportError ( "Error: Handle = %p, MemErr = %i, size = %li", h, MemError (), bytes );
  252.         
  253.         if ( fail )
  254.             BLJFailIfNil ( h, file, line );
  255.     }
  256.     else if ( !clear )
  257.     {
  258.         ::HLock ( h );
  259.         ::memset ( *h, 0xFF, (unsigned int) bytes );
  260.         ::HUnlock ( h );
  261.     }
  262.  
  263.     if ( chrisFlag.Flag ( 9 ) )
  264.         Register ( h, file, line );
  265.  
  266.     return h;
  267. }
  268.  
  269. /***********************************|****************************************/
  270.  
  271. void DeallocatePtr ( Ptr p )
  272. {
  273.     if (!p)
  274.         return;
  275.         
  276.     Size bytes = ::GetPtrSize ( p );
  277.     OSErr error = MemError ();
  278.  
  279.     if ( error != noErr )
  280.     {
  281.         ::ReportError ( "Error: Ptr = %p, MemErr = %i, size = %li", p, error, bytes );
  282.         return;
  283.     }
  284.  
  285.     Unregister ( p );
  286.     ::memset ( p, 0xFF, (unsigned int) bytes );
  287.     ::DisposePtr ( p );
  288.     error = MemError ();
  289.  
  290.     if ( error != noErr )
  291.     {
  292.         ::ReportError ( "Error: Ptr = %p, MemErr = %i", p, error );
  293.     }
  294. }
  295.  
  296. /***********************************|****************************************/
  297.  
  298. void DeallocateHandle ( Handle h )
  299. {
  300.     if (!h)
  301.         return;
  302.         
  303.     Size bytes = ::GetHandleSize ( h );
  304.     OSErr error = MemError ();
  305.  
  306.     if ( error != noErr )
  307.     {
  308.         ::ReportError ( "Error: Handle = %p, MemErr = %i, size = %li", h, error, bytes );
  309.     }
  310.     else
  311.     {
  312.         Unregister ( h );
  313.         ::HLock ( h );
  314.         ::memset ( *h, 0xFF, (unsigned int) bytes );
  315.         ::HUnlock ( h );
  316.         ::DisposeHandle ( h );
  317.         error = MemError ();
  318.  
  319.         if ( error != noErr )
  320.         {
  321.             ::ReportError ( "Error: Handle = %p, MemErr = %i", h, error );
  322.         }
  323.     }
  324. }
  325.  
  326. #endif    // debug
  327.  
  328. /***********************************|****************************************/
  329.  
  330. void* operator new ( size_t size, const void* placement ) 
  331. {
  332.     void* p = nil;
  333.     
  334.     if ( placement == SystemZone () )
  335.     {
  336.         p = ::NewPtrSys ( size );
  337.     }
  338.     else if ( placement == ApplicationZone () )
  339.     {
  340.         p = ::NewPtr ( size );
  341.     }
  342.     else
  343.     {
  344.         Zone* z = ::PtrZone ( (Ptr) placement );
  345.         
  346.         if ( !z || MemError () )
  347.         {
  348.             p = ::NewPtr ( size );
  349.         }
  350.         else
  351.         {
  352.             Zone* saved = GetZone ();
  353.             ::SetZone ( z );
  354.             p = ::NewPtr ( size );
  355.             ::SetZone ( saved );
  356.         }
  357.     }
  358.     
  359.     if ( !p )
  360.         ::ReportError ( "Error: Ptr = %p, MemErr = %i, size = %li", p, MemError (), size );
  361.  
  362.     return p;
  363. }
  364.  
  365. /***********************************|****************************************/
  366.